#!/bin/bash

##
# Fepago: Determina si hay disponibilidad para pagar las facturas, y efectua los pagos.
##


# Funcion que valida el archivo de presupuestos
# $1 - Path al archivo de presupuestos
function validarPresupuesto(){
	cantLineas=$(cat "$1" | wc -l)
	if [ $cantLineas -ne 5 ]
	then
		return 1
	fi
	cantLineas=$(grep -v "^[0-9][0-9];[0-9][0-9]*[.][0-9][0-9];[0-9]\{4\}\-[0-1][0-9]\-[0-3][0-9];" "$1" | wc -l)
	if [ $cantLineas -ne 0 ]
	then
		return 1
	fi
	return 0
}

# Extrae los montos disponibles del archivo de presupuestos, y los carga en memoria.
# $1 - Path al archivo de presupuestos
function getMontos() {
	fuente1=$(awk 'NR==1{print $1}' "$1" | cut -d';' -f2)
	fuente2=$(awk 'NR==2{print $1}' "$1" | cut -d';' -f2)
	fuente3=$(awk 'NR==3{print $1}' "$1" | cut -d';' -f2)
	fuente4=$(awk 'NR==4{print $1}' "$1" | cut -d';' -f2)
	fuente5=$(awk 'NR==5{print $1}' "$1" | cut -d';' -f2)
}

# Valida que el registro pasado por parametro cumpla las condiciones de barrido ingresadas.
# $1 - registro correspondiente a la factura que se quiere validar.
function valRegFactura(){
	res=`echo "$1" | grep ".*;A PAGAR;.*;.*" | wc -l`
	if [ $res -ne 1 ]
	then
		return 1
	fi
	if [ "$2" = "f" ]
	then
		fechaAux=`echo "$linea" | cut -d';' -f3`
		# Me fijo q la fecha no sea menor q la fecha minima
		res1=`compararFechas $fechaAux $fechaDesde`
		# Me fijo q la fecha sea menor o igual q la fecha maxima
		res2=`compararFechas $fechaHasta $fechaAux`
		if [ "$res1" = "-1" -o "$res2" = "-1" ]
		then
			return 1
		fi
	fi
	if [ "$2" = "m" ]
	then
		montoAux=`echo "$linea" | cut -d';' -f4`
		# Me fijo q el monto no sea menor q el monto minimo ingresado
		res1=`echo $montoAux $montoDesde | awk '{if ($1 >= $2) print 0; else print 1}'`
		# Me fijo q el monto no sea mayor que el monto maximo ingrado
		res2=`echo $montoAux $montoHasta | awk '{if ($1 <= $2) print 0; else print 1}'`
		if [ $res1 != "0" -o $res2 != "0" ]
		then
			return 1
		fi
	fi
	if [ "$2" = "fm" ]
	then
		fechaAux=`echo "$linea" | cut -d';' -f3`
		montoAux=`echo "$linea" | cut -d';' -f4`
		# Me fijo q la fecha no sea menor q la fecha minima
		res1=`compararFechas $fechaAux $fechaDesde`
		# Me fijo q la fecha sea menor o igual q la fecha maxima
		res2=`compararFechas $fechaHasta $fechaAux`
		# Me fijo q el monto no sea menor q el monto minimo ingresado
		res3=`echo $montoAux $montoDesde | awk '{if ($1 >= $2) print 0; else print 1}'`
		# Me fijo q el monto no sea mayor que el monto maximo ingrado
		res4=`echo $montoAux $montoHasta | awk '{if ($1 <= $2) print 0; else print 1}'`
		if [ "$res1" = "-1" -o "$res2" = "-1" -o $res3 != "0" -o $res4 != "0" ]
		then
			return 1
		fi
	fi
	return 0
}

# Recibe la ubicacion del archivo de facturas a pagar, y lo procesa en base a los parametros de
# barrido ingresados previamente. A medida que realiza dicho procesamiento, va armando un listado
# de las facturas comprometidas en un archivo auxiliar.
# $1 - Path al archivo de registros
function procesarFacturas() {
	while read linea
	do
		valRegFactura "$linea" "$barrido"
		if [ $? -eq 0 ]
		then
			monto=`echo "$linea" | cut -d';' -f4`
			CAE=`echo "$linea" | cut -d';' -f1`
			procesarMonto $monto
			if [ $? -eq 0 ]
			then
				echo "$linea" | sed /"^$CAE"/s/"A PAGAR"/"LIBERADO"/ >> "$listado"
				sed /"^$CAE"/s/"A PAGAR"/"LIBERADO"/ "$1" > "aux.tmp"
				cat "aux.tmp" > "$1"
			else
				echo "$linea" >> "$listado"
			fi
			if [ -f "aux.tmp" ]
			then
				rm "aux.tmp"
			fi
		fi
	done < "$1"
}



# Recibe un monto, y se fija si hay disponibilidad para pagarlo. Las fuentes deben encontrarse ya cargadas.
# $1 - el monto a pagar.
function procesarMonto() {
	res=`echo $1 $fuente1 | awk '{if (($1 > 0.0) && ($1 <= 1000.0) && ($1 <= $2)) print 0; else print 1}'`
	if [ $res -eq 0 ]
	then	
		fuente1=`echo "scale=2 ; $fuente1 - $1" | bc`
		return 0
	fi
	res=`echo $1 $fuente2 | awk '{if (($1 > 1000.0) && ($1 <= 10000.0) && ($1 <= $2)) print 0; else print 1}'`
	if [ $res -eq 0 ]
	then
		fuente2=`echo "scale=2 ; $fuente2 - $1" | bc`
		return 0
	fi
	res=`echo $1 $fuente3 | awk '{if (($1 > 10000.0) && ($1 <= 50000.0) && ($1 <= $2)) print 0; else print 1}'`
	if [ $res -eq 0 ]
	then
		fuente3=`echo "scale=2 ; $fuente3 - $1" | bc`
		return 0
	fi
	res=`echo $1 $fuente4 | awk '{if (($1 > 50000.0) && ($1 <= 150000.0) && ($1 <= $2)) print 0; else print 1}'`
	if [ $res -eq 0 ]
	then
		fuente4=`echo "scale=2 ; $fuente4 - $1" | bc`
		return 0
	fi
	res=`echo $1 $fuente5 | awk '{if (($1 > 150000.0) && ($1 <= $2)) print 0; else print 1}'`
	if [ $res -eq 0 ]
	then
		fuente5=`echo "scale=2 ; $fuente5 - $1" | bc`
		return 0
	fi
	return 1
}

# Lista las facturas comprometidas
# $listado - path al archivo temporal con el listado de facturas comprometidas
function listarFacturasComprometidas() {
	echo ""
	if [ -f "$listado" ]
	then
		./Glog.sh "$nombreScript" "I" "A continuacion se mostraran las facturas comprometidas por el rango de busqueda especificado:"
		./Glog.sh "$nombreScript" "I" "Formato de los registros: CAE || Fecha de Vencimiento || Monto de la Factura || Estado"
		echo "A continuacion se mostraran las facturas comprometidas por el rango de busqueda especificado:"
		echo "Formato de los registros: CAE || Fecha de Vencimiento || Monto de la Factura || Estado"
		while read linea
		do
			campo1=`echo "$linea" | cut -d';' -f1`
			campo2=`echo "$linea" | cut -d';' -f2`
			campo3=`echo "$linea" | cut -d';' -f3`
			campo4=`echo "$linea" | cut -d';' -f4`
			#Imprimo la linea con el formato pedido
			echo "$campo1  ||  $campo3  ||  $campo4  ||  $campo2"
		done < "$listado"
		rm "$listado"
	else
		./Glog.sh "$nombreScript" "I" "No existen facturas comprometidas por los parametros de busqueda ingresados."
		echo "No existen facturas comprometidas por los parametros de busqueda ingresados."
	fi
	echo ""
}

# Muestra el estado del presupuesto antes y despues de procesar las facturas
# $1 - path al archivo con el presupuesto
function mostrarPresupuesto() {
	codigof1=$(awk 'NR==1{print $1}' "$1" | cut -d';' -f1)
	codigof2=$(awk 'NR==2{print $1}' "$1" | cut -d';' -f1)
	codigof3=$(awk 'NR==3{print $1}' "$1" | cut -d';' -f1)
	codigof4=$(awk 'NR==4{print $1}' "$1" | cut -d';' -f1)
	codigof5=$(awk 'NR==5{print $1}' "$1" | cut -d';' -f1)
	monto1=$(awk 'NR==1{print $1}' "$1" | cut -d';' -f2)
	monto2=$(awk 'NR==2{print $1}' "$1" | cut -d';' -f2)
	monto3=$(awk 'NR==3{print $1}' "$1" | cut -d';' -f2)
	monto4=$(awk 'NR==4{print $1}' "$1" | cut -d';' -f2)
	monto5=$(awk 'NR==5{print $1}' "$1" | cut -d';' -f2)
	./Glog.sh "$nombreScript" "I" ""
	./Glog.sh "$nombreScript" "I" "Estado del presupuesto antes y despues de procesar las facturas:"
	./Glog.sh "$nombreScript" "I" "(Codigo Fuente | Monto Original - Monto Final"
	./Glog.sh "$nombreScript" "I" "$codigof1  |  $monto1  -  $fuente1"
	./Glog.sh "$nombreScript" "I" "$codigof2  |  $monto2  -  $fuente2"
	./Glog.sh "$nombreScript" "I" "$codigof3  |  $monto3  -  $fuente3"
	./Glog.sh "$nombreScript" "I" "$codigof4  |  $monto4  -  $fuente4"
	./Glog.sh "$nombreScript" "I" "$codigof5  |  $monto5  -  $fuente5"
	echo ""
	echo "Estado del presupuesto antes y despues de procesar las facturas:"
	echo "(Codigo Fuente | Monto Original - Monto Final"
	echo "$codigof1  |  $monto1  -  $fuente1"
	echo "$codigof2  |  $monto2  -  $fuente2"
	echo "$codigof3  |  $monto3  -  $fuente3"
	echo "$codigof4  |  $monto4  -  $fuente4"
	echo "$codigof5  |  $monto5  -  $fuente5"

}

function vMove(){
	inputFilename=`echo "$1" | sed 's/^.*\/\(.*\)$/\1/'`
	lastDuplicate=$(ls -1 "$2" | grep -w "$inputFilename\.[0-9]*" | sed 's/.*\/\(.*\)/\1/' | cut -d "." -f 3 | sort | tail --lines=1)
	let duplicateNumber=$lastDuplicate+1

	mv -f "$1" "$2$inputFilename.$duplicateNumber"
	if [ $? -eq 0 ]
	then
		./Glog.sh "$nombreScript" "I" "mover exitoso origen: $1 destino: $2$inputFilename.$duplicateNumber"
	else
		./Glog.sh "$nombreScript" "E" "mover fallo origen: $1 destino: $2$inputFilename.$duplicateNumber"
	fi

}

# Guarda las imagenes de los archivos originales, y actualiza los mismos con los cambios luego de procesar las facturas
function confirmarCambios(){
	vMove "$facturas_a_pagar" "$facturas_a_pagar_old" "$nombreScript"
	mv "$facturas_a_pagar_temp" "$facturas_a_pagar"
	# Se actualiza el archivo de presupuesto
	codigof1=$(awk 'NR==1{print $1}' "$presupuesto" | cut -d';' -f1)
	codigof2=$(awk 'NR==2{print $1}' "$presupuesto" | cut -d';' -f1)
	codigof3=$(awk 'NR==3{print $1}' "$presupuesto" | cut -d';' -f1)
	codigof4=$(awk 'NR==4{print $1}' "$presupuesto" | cut -d';' -f1)
	codigof5=$(awk 'NR==5{print $1}' "$presupuesto" | cut -d';' -f1)
	# Borro el archivo de presupuesto actual	
	vMove "$presupuesto" "$presupuesto_old" "$nombreScript"
	# Lo vuelvo a crear con la data actualizada
	echo "$codigof1;$fuente1;$fechaHoy;$usuario" >> $presupuesto
	echo "$codigof2;$fuente2;$fechaHoy;$usuario" >> $presupuesto
	echo "$codigof3;$fuente3;$fechaHoy;$usuario" >> $presupuesto
	echo "$codigof4;$fuente4;$fechaHoy;$usuario" >> $presupuesto
	echo "$codigof5;$fuente5;$fechaHoy;$usuario" >> $presupuesto
}

# Deja todo como si nunca se hubiese corrido fepago
function deshacerCambios(){
	rm "$facturas_a_pagar_temp"
}

function ingresarModo() {
	echo -n "Ingrese el modo de ejecucion. Los valores posibles son \"s\" (Simulacion) o \"a\" (Actualizacion): "
	./Glog.sh "$nombreScript" "I" "Ingrese el modo de ejecucion. Los valores posibles son \"s\" (Simulacion) o \"a\" (Actualizacion): "
	read modo
	if [ $modo != "s" -a $modo != "a" ]
	then
		echo "El modo de ejecucion ingresado es invalido."
		./Glog.sh "$nombreScript" "E" "El modo de ejecucion ingresado es invalido."
		ingresarModo
	fi
	./Glog.sh "$nombreScript" "I" "Modo ingresado: $modo"
}

function ingresarBarrido() {
	echo -n "Ingrese el modo de barrido. Los valores posibles son \"f\" (barrido por fecha) ,\"m\" (barrido por monto) o \"fm\" (barrido por fecha y monto): "
	./Glog.sh "$nombreScript" "I" "Ingrese el modo de barrido. Los valores posibles son \"f\" (barrido por fecha) ,\"m\" (barrido por monto) o \"fm\" (barrido por fecha y monto): "
	read barrido
	# Se controla la validez del parametro de barrido
	if [ $barrido != "f" -a $barrido != "m" -a $barrido != "fm" ]
	then
		echo "El modo de barrido ingresado es invalido."
		./Glog.sh "$nombreScript" "E" "El modo de barrido ingresado es invalido."
 		ingresarBarrido
	fi
	./Glog.sh "$nombreScript" "I" "Modo de barrido ingresado: $barrido"
}

function ingresarFechaDesde(){
	echo -n "Ingrese la fecha inicial: "
	./Glog.sh "$nombreScript" "I" "Ingrese la fecha inicial: "
	read fechaDesde
	validarFecha $fechaDesde
	if [ $? -ne 0 ]
	then
		./Glog.sh "$nombreScript" "E" "La fecha ingresada es invalida."
		ingresarFechaDesde
	fi
	./Glog.sh "$nombreScript" "I" "La fecha inicial ingresada es: $fechaDesde"
}

function ingresarFechaHasta(){
	echo -n "Ingrese la fecha final: "
	./Glog.sh "$nombreScript" "I" "Ingrese la fecha final: "
	read fechaHasta
	validarFecha $fechaHasta
	if [ $? -ne 0 ]
	then
		./Glog.sh "$nombreScript" "E" "La fecha ingresada es invalida."
		ingresarFechaDesde
	fi
	comparacion=`compararFechas $fechaHasta $fechaDesde`
	if [ "$comparacion" != "1" -a "$comparacion" != "0" ]
	then
		echo "La fecha final no puede ser menor que la inicial."
		./Glog.sh "$nombreScript" "E" "La fecha final no puede ser menor que la inicial."
		ingresarFechaDesde
	fi
	./Glog.sh "$nombreScript" "I" "La fecha final ingresada es: $fechaHasta"
}

function ingresarMontoDesde(){
	echo -n "Ingrese el monto minimo: "
	./Glog.sh "$nombreScript" "I" "Ingrese el monto minimo: "
	read montoDesde
	res=`echo $montoDesde | grep "^[0-9][0-9]*[.][0-9][0-9]$" | wc -l`
	if [ $res -eq 0 ]
	then
		echo "El formato del monto ingresado ($montoDesde) no es correcto (debe ser un numero con 2 decimales, separados por un punto)."
		./Glog.sh "$nombreScript" "E" "El formato del monto ingresado ($montoDesde) no es correcto (debe ser un numero con 2 decimales, separados por un punto)."
		ingresarMontoDesde
	fi
	./Glog.sh "$nombreScript" "I" "El monto minimo ingresado es: $montoDesde"
}

function ingresarMontoHasta(){ 
	echo -n "Ingrese el monto maximo: "
	./Glog.sh "$nombreScript" "I" "Ingrese el monto maximo: "
	read montoHasta
	res=`echo $montoHasta | grep "^[0-9][0-9]*[.][0-9][0-9]$" | wc -l`
	if [ $res -eq 0 ]
	then
		echo "El formato del monto ingresado ($montoHasta) no es correcto (debe ser un numero con 2 decimales, separados por un punto)."
		./Glog.sh "$nombreScript" "E" "El formato del monto ingresado ($montoHasta) no es correcto (debe ser un numero con 2 decimales, separados por un punto)."
		ingresarMontoHasta
	fi
	res=`echo $montoDesde $montoHasta | awk '{if ($1 <= $2) print 0; else print 1}'`
	if [ $res -ne 0 ]
	then
		echo "El monto maximo debe ser mas grande que el minimo"
		./Glog.sh "$nombreScript" "E" "El monto maximo debe ser mas grande que el minimo"
		echo "Monto minimo actual: $montoDesde - Monto maximo ingresado: $montoHasta"
		./Glog.sh "$nombreScript" "E" "Monto minimo actual: $montoDesde - Monto maximo ingresado: $montoHasta"
		ingresarMontoHasta
	fi
	./Glog.sh "$nombreScript" "I" "Monto maximo ingresado $modoDesde"
}

# Funcion q ejecuta la funcionalidad del comando fepago
# $1 - Modo de ejecucion (Actualizacion o Simulacion)
# $2 - Modo de barrido (Por Fecha, por Monto o por Fecha y Monto)
# $3 - FechaDesde
# $4 - FechaHasta
# $5 - MontoDesde
# $6 - MontoHasta
function ejecutarFepago(){
	./Glog.sh "$nombreScript" "I" "Inicio de fepago: $1 $2 $3 $4 $5 $6"

	getMontos $presupuesto
	# creo una copia de respaldo para el archivo de facturas a pagar
	cp "$facturas_a_pagar" "$facturas_a_pagar_temp"
	procesarFacturas "$facturas_a_pagar_temp"
	listarFacturasComprometidas "$facturas_a_pagar"
	mostrarPresupuesto $presupuesto
	if [ $1 = "a" -o $1 = "A" ]
	then
		confirmarCambios
	else
		deshacerCambios
	fi
}

function iniciarFepago() {
	./Glog.sh "$nombreScript" "I" "Bienvenido a la ejecucion de fepago!"
	echo "Bienvenido a la ejecucion de fepago!"
	# Ingresar modo de ejecucion ($modo)
	ingresarModo
	# Ingresar modo de barrido ($barrido)
	ingresarBarrido
	# Ingresar parametros de barrido 
	# $fechaDesde / $fechaHasta / $montoDesde / $montoHasta
	if [ $barrido = "f" ]
	then
		ingresarFechaDesde
		ingresarFechaHasta
	else
		fechaDesde=""
		fechaHasta=""
	fi
	if [ $barrido = "m" ]
	then
		ingresarMontoDesde
		ingresarMontoHasta
	else
		montoDesde=""
		montoHasta=""
	fi
	if [ $barrido = "fm" ]
	then
		ingresarFechaDesde
		ingresarFechaHasta
		ingresarMontoDesde
		ingresarMontoHasta
	fi
	ejecutarFepago $modo $barrido $fechaDesde $fechaHasta $montoDesde $montoHasta
}


##                 ##
# Inicio del Script #
##                 ##

source util.sh

#Variables Locales
usuario=`whoami`
presupuesto="$grupo/prin/presu.txt"
presupuesto_old="$grupo/prin/old/"
facturas_a_pagar="$grupo/facturas/apagar.txt"
facturas_a_pagar_temp="$grupo/facturas/apagar.tmp"
facturas_a_pagar_old="$grupo/facturas/old/"
listado="listado.tmp"
nombreScript="fepago.sh"
fechaHoy=`date +%Y-%m-%d`

./Glog.sh "$nombreScript" "I" ""
echo ""
echo "comienza a correr fepago"
estaEjecutandose $nombreScript
if [ $? -eq 0 ]
then
	./Glog.sh "$nombreScript" "I" "Una instancia de fepago se encuentra corriendo actualmente. No puede ejecutarse mas de una instancia del mismo por vez."
	echo "Una instancia de fepago se encuentra corriendo actualmente. No puede ejecutarse mas de una instancia del mismo por vez."
	exit 1
fi

if [ -z $FEENV ]
then
	./Glog.sh "$nombreScript" "E" "El ambiente no fue inicializado. Debera inicializarlo antes de ejecutar este comando."
	echo "El ambiente no fue inicializado. Debera inicializarlo antes de ejecutar este comando."
	exit 1
fi

estaEjecutandose "feprima.sh"
if [ $? -eq 0 ]
then
	./Glog.sh "$nombreScript" "I" "Una instancia de feprima se encuentra corriendo actualmente. No puede ejecutarse fepago hasta que finalize la ejecucion de feprima."
	echo "Una instancia de feprima se encuentra corriendo actualmente. No puede ejecutarse fepago hasta que finalize la ejecucion de feprima."
	exit 1
fi

validarPresupuesto "$presupuesto"
if [ $? -ne 0 ]
then
	./Glog.sh "$nombreScript" "E" "El formato del archivo de presupuesto no es valido."
	echo "El formato del archivo de presupuesto no es valido."
	exit 1
fi

repetir="r"
while [ $repetir = "r" ]
do
	iniciarFepago
	echo ""
	echo -n "Presione \"r\" para repetir la ejecucion de fepago, o cualquier otra tecla para salir: "
	read repetir
done
./Glog.sh "$nombreScript" "I" "se termino de ejecutar fepago"
exit 0

